
/**
 * 接口
 * 抽象类是从多个类中抽象出来的模板，如果将这种抽象进行得更彻底，则可以提炼出一种更加特殊的“抽象类”—接口（interface）。
 * <p>
 * 和类定义不同，定义接口不再使用class关键字，而是使用interface关键字。接口定义的基本语法如下：
 * <pre>
 *     [修饰符] interface 接口名 extends 父接口1, 父接口2...
 *     {
 *         零个到多个常亮定义...
 *         零个到多个抽象方法定义...
 *         零个到多个内部类、接口、枚举定义...
 *         零个到多个私有方法、默认方法或类方法定义...  // 只有在Java 8以上的版本中才允许在接口中定义默认方法、类方法。
 *     }
 * </pre>
 * <p>
 * 对上面语法的详细说明如下。
 * ➢ 修饰符可以是public或者省略，如果省略了public访问控制符，则默认采用包权限访问控制符，即只有在相同包结构下才可以访问该接口。
 * ➢ 接口名应与类名采用相同的命名规则，即如果仅从语法角度来看，接口名只要是合法的标识符即可；
 * 如果要遵守Java可读性规范，则接口名应由多个有意义的单词连缀而成，每个单词首字母大写，单词与单词之间无须任何分隔符。
 * 接口名通常能够使用形容词。
 * ➢ 一个接口可以有多个直接父接口，但接口只能继承接口，不能继承类。
 * <p>
 * 由于接口定义的是一种规范，因此接口里不能包含构造器和初始化块定义。
 * 接口里可以包含成员变量（只能是静态常量）、方法（只能是抽象实例方法、类方法、默认方法或私有方法）、内部类（包括内部接口、枚举）定义。
 * <p>
 * 对比接口和类的定义方式，不难发现接口的成员比类里的成员少了两种，而且接口里的成员变量只能是静态常量，
 * 接口里的方法只能是抽象方法、类方法、默认方法或私有方法。
 * <p>
 * Java 9为接口增加了一种新的私有方法，其实私有方法的主要作用就是作为工具方法，为接口中的默认方法或类方法提供支持。
 * 私有方法可以拥有方法体，但私有方法不能使用default修饰。
 * 私有方法可以使用static修饰，也就是说，私有方法既可是类方法，也可是实例方法。
 * <p>
 * 对于接口里定义的静态常量而言，它们是接口相关的，因此系统会自动为这些成员变量增加static和final两个修饰符。
 * 也就是说，在接口中定义成员变量时，不管是否使用public static final修饰符，接口里的成员变量总是使用这三个修饰符来修饰。
 * 而且接口里没有构造器和初始化块，因此接口里定义的成员变量只能在定义时指定默认值。
 * <p>
 * 接口里定义的方法只能是抽象方法、类方法、默认方法或私有方法，因此如果不是定义默认方法、类方法或私有方法，
 * 系统将自动为普通方法增加abstract修饰符；定义接口里的普通方法时不管是否使用public abstract修饰符，
 * 接口里的普通方法总是使用public abstract来修饰。
 * 接口里的普通方法不能有方法实现（方法体）；但类方法、默认方法、私有方法都必须有方法实现（方法体）。
 * <p>
 * 注意：接口里定义的内部类、内部接口、内部枚举默认都采用public static两个修饰符，
 * 不管定义时是否指定这两个修饰符，系统都会自动使用public static对它们进行修饰。
 * <p>
 * 从Java 8开始，在接口里允许定义默认方法，默认方法必须使用default修饰，该方法不能使用static修饰，
 * 无论程序是否指定，默认方法总是使用public修饰——如果开发者没有指定public，系统会自动为默认方法添加public修饰符。
 * 由于默认方法并没有static修饰，因此不能直接使用接口来调用默认方法，需要使用接口的实现类的实例来调用这些默认方法。
 * 提示：接口的默认方法其实就是实例方法，但由于早期Java的设计是：接口中的实例方法不能有方法体；
 * Java 8也不能直接“推倒”以前的规则，因此只好重定义一个所谓的“默认方法”，默认方法就是有方法体的实例方法。
 * <p>
 * 从Java 8开始，在接口里允许定义类方法，类方法必须使用static修饰，该方法不能使用default修饰，
 * 无论程序是否指定，类方法总是使用public修饰——如果开发者没有指定public，系统会自动为类方法添加public修饰符。
 * 类方法可以直接使用接口来调用。
 * <p>
 * 即：在接口里，default和static不能同时出现，要么是默认方法，要么是类方法
 * <p>
 * 接口里的成员变量默认是使用public static final修饰的，因此即使另一个类处于不同包下，也可以通过接口来访问接口里的成员变量。
 * <p>
 * 注意：从某个角度来看，接口可被当成一个特殊的类，因此一个Java源文件里最多只能有一个public接口，
 * 如果一个Java源文件里定义了一个public接口，则该源文件的主文件名必须与该接口名相同。
 */
interface Output {
    // 接口里定义的成员变量只能是常量
    int MAX_CHAGE_LINE = 50;

    // 接口里定义的普通方法只能是public的抽象方法
    void out();

    void getData(String msg);

    // 在接口中定义默认方法，需要使用default修饰
    default void print(String... msgs) {
        for (String msg : msgs) {
            System.out.println(msg);
        }
    }

    default void test() {
        System.out.println("默认的test()方法");
    }

    // 在接口中定义类方法，需要使用static修饰
    static String staticTest() {
        return "接口里的类方法";
    }
    // 定义私有方法 java9才支持
//    private void foo() {
//        System.out.println("foo私有方法");
//    }
    // 定义私有静态方法 java9才支持
//    private static void bar() {
//        System.out.println("bar私有静态方法");
//    }
}

/**
 * 接口的继承
 * 接口的继承和类继承不一样，接口完全支持多继承，即一个接口可以有多个直接父接口。
 * 和类继承相似，子接口扩展某个父接口，将会获得父接口里定义的所有抽象方法、常量。
 * 一个接口继承多个父接口时，多个父接口排在extends关键字之后，多个父接口之间以英文逗号（,）隔开。
 * 下面程序定义了三个接口，第三个接口继承了前面两个接口。
 */
interface InterfaceA {
    int PROP_A = 5;

    void testA();
}

interface InterfaceB {
    int PROP_B = 6;

    void testB();
}

interface InterfaceC extends InterfaceA, InterfaceB {
    int PROP_C = 7;

    void testC();
}

class InterfaceExtendsTest {
    public static void test() {
        System.out.println(InterfaceC.PROP_A);
        System.out.println(InterfaceC.PROP_B);
        System.out.println(InterfaceC.PROP_C);
    }
}

/**
 * 使用接口
 * <p>
 * 接口不能用于创建实例，但接口可以用于声明引用类型变量。
 * 当使用接口来声明引用类型变量时，这个引用类型变量必须引用到其实现类的对象。
 * 除此之外，接口的主要用途就是被实现类实现。
 * 归纳起来，接口主要有如下用途。
 * ➢ 定义变量，也可用于进行强制类型转换。
 * ➢ 调用接口中定义的常量。
 * ➢ 被其他类实现。
 * <p>
 * 一个类可以实现一个或多个接口，继承使用extends关键字，实现则使用implements关键字。
 * 因为一个类可以实现多个接口，这也是Java为单继承灵活性不足所做的补充。
 * 类实现接口的语法格式如下：
 * <pre>
 *     [修饰符] class 类名 extends 父类 implements 接口1, 接口2...
 *     {
 *         类体部分
 *     }
 * </pre>
 * <p>
 * implements部分必须放在extends部分之后。
 * <p>
 * 一个类实现了一个或多个接口之后，这个类必须完全实现这些接口里所定义的全部抽象方法（也就是重写这些抽象方法）；
 * 否则，该类将保留从父接口那里继承到的抽象方法，该类也必须定义成抽象类。
 * <p>
 * 一个类实现某个接口时，该类将会获得接口中定义的常量（成员变量）、方法等，
 * 因此可以把实现接口理解为一种特殊的继承，相当于实现类继承了一个彻底抽象的类（相当于除默认方法外，所有方法都是抽象方法的类）。
 */
// 定义一个Product接口
interface Product {
    int getProduceTime();
}

// 让Printer类实现Output和Product类
class Printer implements Output, Product {
    private String[] printData = new String[MAX_CHAGE_LINE];
    private int dataNum = 0;    // 记录当前需要打印的作业数

    @Override
    public void out() {
        while (dataNum > 0) {
            System.out.println("打印机打印：" + printData[0]);
            // 把作业队列整体前移一位，并将剩下的作业数减1
            System.arraycopy(printData, 1, printData, 0, --dataNum);
        }
    }

    @Override
    public void getData(String msg) {
        if (dataNum > MAX_CHAGE_LINE) {
            System.out.println("输出队列已满，添加失败");
        } else {
            // 把打印数据添加到队列里，以保持数据的数量加1
            printData[dataNum++] = msg;
        }
    }

    @Override
    public int getProduceTime() {
        return 45;
    }

    public static void test1() {
        // 创建一个Printer对象，当成Output使用
        Output o = new Printer();
        o.getData("学习Java");
        o.getData("Java接口");
        o.out();
        o.getData("Java接口");
        o.getData("面向接口编程");
        o.out();
        // 调用Output接口中定义的默认方法
        o.print("孙悟空", "猪八戒", "白骨精");
        o.test();
        // 创建一个Printer对象，当成Product使用
        Product p = new Printer();
        System.out.println(p.getProduceTime());
        // 所有接口类型的引用变量都可以直接赋给Object类型的变量
        Object obj = p;
    }
}

/**
 * 注意：实现接口方法时，必须使用public访问控制修饰符，因为接口里的方法都是public的，
 * 而子类（相当于实现类）重写父类方法时访问权限只能更大或者相等，所以实现类实现接口里的方法时只能使用public访问权限。
 * <p>
 * 接口不能显式继承任何类，但所有接口类型的引用变量都可以直接赋给Object类型的引用变量。
 * 所以在上面程序中可以把Product类型的变量直接赋给Object类型变量，这是利用向上转型来实现的，
 * 因为编译器知道任何Java对象都必须是Object或其子类的实例，
 * Product类型的对象也不例外（它必须是Product接口实现类的对象，该实现类肯定是Object的显式或隐式子类）。
 */

/**
 * 接口和抽象类
 * 接口和抽象类很像，它们都具有如下特征。
 * ➢ 接口和抽象类都不能被实例化，它们都位于继承树的顶端，用于被其他类实现和继承。
 * ➢ 接口和抽象类都可以包含抽象方法，实现接口或继承抽象类的普通子类都必须实现这些抽象方法。
 * <p>
 * 但接口和抽象类之间的差别非常大，这种差别主要体现在二者设计目的上。下面具体分析二者的差别。
 * <p>
 * 接口作为系统与外界交互的窗口，接口体现的是一种规范。
 * 对于接口的实现者而言，接口规定了实现者必须向外提供哪些服务（以方法的形式来提供）；
 * 对于接口的调用者而言，接口规定了调用者可以调用哪些服务，以及如何调用这些服务（就是如何来调用方法）。
 * 当在一个程序中使用接口时，接口是多个模块间的耦合标准；当在多个应用程序之间使用接口时，接口是多个程序之间的通信标准。
 * <p>
 * 从某种程度上来看，接口类似于整个系统的“总纲”，它制定了系统各模块应该遵循的标准，因此一个系统中的接口不应该经常改变。
 * 一旦接口被改变，对整个系统甚至其他系统的影响将是辐射式的，导致系统中大部分类都需要改写。
 * <p>
 * 抽象类则不一样，抽象类作为系统中多个子类的共同父类，它所体现的是一种模板式设计。
 * 抽象类作为多个子类的抽象父类，可以被当成系统实现过程中的中间产品，
 * 这个中间产品已经实现了系统的部分功能（那些已经提供实现的方法），但这个产品依然不能当成最终产品，
 * 必须有更进一步的完善，这种完善可能有几种不同方式。
 *
 * 除此之外，接口和抽象类在用法上也存在如下差别。
 * ➢ 接口里只能包含抽象方法、静态方法、默认方法和私有方法，不能为普通方法提供方法实现；抽象类则完全可以包含普通方法。
 * ➢ 接口里只能定义静态常量，不能定义普通成员变量；抽象类里则既可以定义普通成员变量，也可以定义静态常量。
 * ➢ 接口里不包含构造器；抽象类里可以包含构造器，抽象类里的构造器并不是用于创建对象，而是让其子类调用这些构造器来完成属于抽象类的初始化操作。
 * ➢ 接口里不能包含初始化块；但抽象类则完全可以包含初始化块。
 * ➢ 一个类最多只能有一个直接父类，包括抽象类；但一个类可以直接实现多个接口，通过实现多个接口可以弥补Java单继承的不足。
 */

/**
 * 面向接口编程
 * 很多软件架构设计理论都倡导“面向接口”编程，而不是面向实现类编程，希望通过面向接口编程来降低程序的耦合。
 */

/**
 * “简单工厂”的设计模式。
 * 有一个场景：假设程序中有个Computer类需要组合一个输出设备，
 * 现在有两个选择：直接让Computer类组合一个Printer，或者让Computer类组合一个Output，那么到底采用哪种方式更好呢？
 * 如果有一天系统需要重构，需要使用BetterPrinter来代替Printer，
 *
 * 工厂模式建议让Computer类组合一个Output类型的对象，将Computer类与Printer类完全分离。
 * Computer对象实际组合的是Printer对象还是BetterPrinter对象，对Computer而言完全透明。
 * 当Printer对象切换到BetterPrinter对象时，系统完全不受影响。
 */
class Computer {
    private Output out;

    public Computer(Output out) {
        this.out = out;
    }

    public void keyIn(String msg) {
        out.getData(msg);

    }

    public void print() {
        out.out();
    }
}

class OutputFactory {
    public Output getOutput() {
        return new Printer();
    }

    public static void test() {
        OutputFactory of = new OutputFactory();
        Computer c = new Computer(of.getOutput());
        c.keyIn("学习Java编程");
        c.keyIn("面向接口编程");
        c.print();
    }
}

/**
 * 如果系统需要将Printer改为BetterPrinter实现类，只需让BetterPrinter实现Output接口，并改变OutputFactory类中的getOutput()方法即可。
 */
class BetterPrinter implements Output {
    private String[] printData = new String[MAX_CHAGE_LINE * 2];
    private int dataNum = 0;

    @Override
    public void out() {
        while (dataNum > 0) {
            System.out.println("高速打印机正在打印: " + printData[0]);
            System.arraycopy(printData, 1, printData, 0, --dataNum);
        }
    }

    @Override
    public void getData(String msg) {
        if (dataNum >= MAX_CHAGE_LINE * 2) {
            System.out.println("输出队列已满，添加失败");
        } else {
            printData[dataNum++] = msg;
        }
    }
}

/**
 * 上面的BetterPrinter类也实现了Output接口，因此也可当成Output对象使用，于是只要把OutputFactory工厂类的getOutput()方法中粗体部分改为如下代码：
 * 新创建一个OutputFactory2用于演示，相比较OutputFactory只修改了getOutput方法
 */
class OutputFactory2 {
    public Output getOutput() {
        return new BetterPrinter();
    }

    public static void test() {
        OutputFactory2 of = new OutputFactory2();
        Computer c = new Computer(of.getOutput());
        c.keyIn("学习Java编程");
        c.keyIn("面向接口编程");
        c.print();
    }
}

/**
 * 命令模式
 * 考虑这样一种场景：某个方法需要完成某一个行为，但这个行为的具体实现无法确定，必须等到执行该方法时才可以确定。
 * 具体一点：假设有个方法需要遍历某个数组的数组元素，但无法确定在遍历数组元素时如何处理这些元素，需要在调用该方法时指定具体的处理行为。
 * 对于这样一个需求，必须把“处理行为”作为参数传入该方法，这个“处理行为”用编程来实现就是一段代码。
 * 那如何把这段代码传入该方法呢？
 */
interface Command {
    // 接口里定义的process方法用于封装“处理行为”
    void process(int element);
}

/**
 * 下面是需要处理数组的处理类，在这个处理类中包含一个process()方法，
 * 这个方法无法确定处理数组的处理行为，所以定义该方法时使用了一个Command参数，这个Command参数负责对数组的处理行为。
 * 该类的程序代码如下
 */
class ProcessArray {
    public void process(int[] target, Command cmd) {
        for (int t : target) {
            cmd.process(t);
        }
    }
}

/**
 * 通过一个Command接口，就实现了让ProcessArray类和具体“处理行为”的分离，程序使用Command接口代表了对数组元素的处理行为。
 * Command接口也没有提供真正的处理，只有等到需要调用ProcessArray对象的process()方法时，才真正传入一个Command对象，才确定对数组的处理行为。
 */

class CommandTest {
    public static void test() {
        ProcessArray pa = new ProcessArray();
        int[] target = {3, -4, 6, 4};
        // 第一次处理数组，具体处理行为取决于PrintCommand
        pa.process(target, new PrintCommand());
        System.out.println("-----------------------------");
        // 第二次处理数组，具体处理行为取决于SquareCommand
        pa.process(target, new SquareCommand());
    }
}

class PrintCommand implements Command {
    @Override
    public void process(int element) {
        System.out.println("迭代输出目标数组的元素：" + element);
    }
}

class SquareCommand implements Command {
    @Override
    public void process(int element) {
        System.out.println("数组元素的平方是：" + element * element);
    }
}

/**
 * 对于PrintCommand和SquareCommand两个实现类而言，实际有意义的部分就是process(int element)方法，
 * 该方法的方法体就是传入ProcessArray类里的process()方法的“处理行为”，通过这种方式就可实现process()方法和“处理行为”的分离。
 */

public class InterfaceTest {
    public static void main(String[] args) {
        InterfaceExtendsTest.test();
        Printer.test1();
        OutputFactory.test();
        OutputFactory2.test();
        CommandTest.test();
    }
}
